What is the `Array.prototype.sort` method in JavaScript?

`Array.prototype.reduceRight` applies a function against an accumulator and each element of the array from right to left. It is similar to `reduce`, but processes elements in reverse order. 

const arr = [1, 2, 3];
const result = arr.reduceRight((acc, num) => acc + num);
console.log(result); // 6

`Array.prototype.includes` checks if an array contains a specified element and returns `true` if it is found, otherwise `false`. It is case-sensitive and supports an optional starting index. 

const arr = [1, 2, 3];
console.log(arr.includes(2)); // true
console.log(arr.includes(4)); // false

`Array.prototype.fill` fills all elements of an array from a start index to an end index with a static value. It modifies the original array and returns the updated array. 

const arr = [1, 2, 3, 4];
arr.fill(0, 1, 3);
console.log(arr); // [1, 0, 0, 4]

`Array.prototype.concat` merges two or more arrays into a new array. It does not modify the original arrays and can take any number of arguments, including arrays and values. 

const arr1 = [1, 2];
const arr2 = [3, 4];
const merged = arr1.concat(arr2);
console.log(merged); // [1, 2, 3, 4]

`Array.prototype.some` tests whether at least one element in the array passes a provided test function. It returns `true` if at least one element satisfies the condition, otherwise `false`. It does not modify the original array. 

const arr = [1, 2, 3];
const hasEven = arr.some(num => num % 2 === 0);
console.log(hasEven); // true

`Array.prototype.join` joins all elements of an array into a string, with elements separated by a specified separator. The default separator is a comma if none is provided. 

const arr = ['a', 'b', 'c'];
console.log(arr.join('-')); // 'a-b-c'

`Array.prototype.slice` returns a shallow copy of a portion of an array into a new array object, selected from start to end (end not included). It does not modify the original array. 

const arr = [1, 2, 3, 4];
const sliced = arr.slice(1, 3);
console.log(sliced); // [2, 3]

`Array.prototype.fill` fills all the elements of an array from a specified start index to an end index with a static value. It modifies the original array and returns the updated array. 

const arr = [1, 2, 3, 4];
arr.fill(0, 1, 3);
console.log(arr); // [1, 0, 0, 4]

`Array.prototype.lastIndexOf` returns the index of the last occurrence of a specified element within the array. If the element is not found, it returns `-1`. It performs a strict comparison (===). 

const arr = [1, 2, 3, 2];
console.log(arr.lastIndexOf(2)); // 3
console.log(arr.lastIndexOf(4)); // -1

`Array.prototype.every` tests whether all elements in the array pass a provided test function. It returns `true` if all elements pass the test, otherwise `false`. It does not modify the original array. 

const arr = [2, 4, 6];
const allEven = arr.every(num => num % 2 === 0);
console.log(allEven); // true

`Array.prototype.splice` changes the contents of an array by removing, replacing, or adding elements at a specified index. It modifies the original array and returns an array of removed elements. 

const arr = [1, 2, 3];
arr.splice(1, 1, 'a', 'b');
console.log(arr); // [1, 'a', 'b', 3]

`Array.prototype.indexOf` returns the index of the first occurrence of a specified element within the array. If the element is not found, it returns `-1`. It performs a strict comparison (===). 

const arr = ['a', 'b', 'c'];
console.log(arr.indexOf('b')); // 1
console.log(arr.indexOf('d')); // -1

`Array.prototype.sort` sorts the elements of an array in place and returns the sorted array. The sorting is based on the UTF-16 code units of the elements by default, but can be customized with a comparison function. 

const arr = [3, 1, 2];
arr.sort();
console.log(arr); // [1, 2, 3]

`Array.prototype.slice` returns a shallow copy of a portion of an array into a new array object, selected from start to end (end not included). It does not modify the original array. 

const arr = [1, 2, 3, 4];
const sliced = arr.slice(1, 3);
console.log(sliced); // [2, 3]

`Array.prototype.copyWithin` shallow copies a portion of the array to another location within the same array. It modifies the original array and returns the modified array. 

const arr = [1, 2, 3, 4];
arr.copyWithin(0, 2, 4);
console.log(arr); // [3, 4, 3, 4]

`Array.prototype.from` creates a new array instance from an array-like or iterable object. It can also take a map function to modify the elements while creating the new array. 

const arrLike = { length: 3, 0: 'a', 1: 'b', 2: 'c' };
const arr = Array.from(arrLike);
console.log(arr); // ['a', 'b', 'c']

`Array.prototype.some` tests whether at least one element in the array passes a provided test function. It returns `true` if at least one element satisfies the condition, otherwise `false`. It does not modify the original array. 

const arr = [1, 2, 3];
const hasEven = arr.some(num => num % 2 === 0);
console.log(hasEven); // true

`Array.prototype.includes` determines whether an array contains a certain value among its entries. It returns `true` if the array contains the value, otherwise `false`. 

const arr = [1, 2, 3];
console.log(arr.includes(2)); // true
console.log(arr.includes(4)); // false

`Array.prototype.sort` sorts the elements of an array in place and returns the sorted array. By default, it sorts elements as strings. A custom comparator function can be provided to sort elements in other ways. 

const arr = [3, 1, 2];
arr.sort();
console.log(arr); // [1, 2, 3]

`String.prototype.indexOf` returns the index of the first occurrence of a specified value in a string. If the value is not found, it returns -1. 

const str = 'hello';
const index = str.indexOf('l');
console.log(index); // 2

`String.prototype.localeCompare` compares two strings in the current locale and returns a number indicating whether the calling string comes before, after, or is equal to the compared string. 

const str1 = 'apple';
const str2 = 'banana';
const result = str1.localeCompare(str2);
console.log(result); // -1 (str1 is less than str2)

`String.prototype.fontcolor` returns a string wrapped in HTML `<font>` tags with a specified color. This method is deprecated and should not be used in modern applications. 

const str = 'hello';
const coloredStr = str.fontcolor('red');
console.log(coloredStr); // '<font color="red">hello</font>'

`String.prototype.fontsize` returns a string wrapped in HTML `<font>` tags with a specified size. This method is deprecated and should not be used in modern applications. 

const str = 'hello';
const sizedStr = str.fontsize(7);
console.log(sizedStr); // '<font size="7">hello</font>'

`String.prototype.anchor` creates an HTML `<a>` element wrapping the string with a specified name attribute. This method is deprecated and should not be used in modern applications. 

const str = 'Click here';
const anchoredStr = str.anchor('top');
console.log(anchoredStr); // '<a name="top">Click here</a>'

`String.prototype.small` returns a string wrapped in HTML `<small>` tags. This method is deprecated and should not be used in modern applications. 

const str = 'hello';
const smallStr = str.small();
console.log(smallStr); // '<small>hello</small>'